home *** CD-ROM | disk | FTP | other *** search
/ Freelog 100 / FreelogNo100-NovembreDecembre2010.iso / Musique / solfege / solfege-win32-3.17.0.exe / {app} / bin / Lib / compiler / ast.py < prev    next >
Text File  |  2006-08-17  |  37KB  |  1,357 lines
  1. """Python abstract syntax node definitions
  2.  
  3. This file is automatically generated by Tools/compiler/astgen.py
  4. """
  5. from compiler.consts import CO_VARARGS, CO_VARKEYWORDS
  6.  
  7. def flatten(seq):
  8.     l = []
  9.     for elt in seq:
  10.         t = type(elt)
  11.         if t is tuple or t is list:
  12.             for elt2 in flatten(elt):
  13.                 l.append(elt2)
  14.         else:
  15.             l.append(elt)
  16.     return l
  17.  
  18. def flatten_nodes(seq):
  19.     return [n for n in flatten(seq) if isinstance(n, Node)]
  20.  
  21. nodes = {}
  22.  
  23. class Node:
  24.     """Abstract base class for ast nodes."""
  25.     def getChildren(self):
  26.         pass # implemented by subclasses
  27.     def __iter__(self):
  28.         for n in self.getChildren():
  29.             yield n
  30.     def asList(self): # for backwards compatibility
  31.         return self.getChildren()
  32.     def getChildNodes(self):
  33.         pass # implemented by subclasses
  34.  
  35. class EmptyNode(Node):
  36.     pass
  37.  
  38. class Expression(Node):
  39.     # Expression is an artificial node class to support "eval"
  40.     nodes["expression"] = "Expression"
  41.     def __init__(self, node):
  42.         self.node = node
  43.  
  44.     def getChildren(self):
  45.         return self.node,
  46.  
  47.     def getChildNodes(self):
  48.         return self.node,
  49.  
  50.     def __repr__(self):
  51.         return "Expression(%s)" % (repr(self.node))
  52.  
  53. class Add(Node):
  54.     def __init__(self, (left, right), lineno=None):
  55.         self.left = left
  56.         self.right = right
  57.         self.lineno = lineno
  58.  
  59.     def getChildren(self):
  60.         return self.left, self.right
  61.  
  62.     def getChildNodes(self):
  63.         return self.left, self.right
  64.  
  65.     def __repr__(self):
  66.         return "Add((%s, %s))" % (repr(self.left), repr(self.right))
  67.  
  68. class And(Node):
  69.     def __init__(self, nodes, lineno=None):
  70.         self.nodes = nodes
  71.         self.lineno = lineno
  72.  
  73.     def getChildren(self):
  74.         return tuple(flatten(self.nodes))
  75.  
  76.     def getChildNodes(self):
  77.         nodelist = []
  78.         nodelist.extend(flatten_nodes(self.nodes))
  79.         return tuple(nodelist)
  80.  
  81.     def __repr__(self):
  82.         return "And(%s)" % (repr(self.nodes),)
  83.  
  84. class AssAttr(Node):
  85.     def __init__(self, expr, attrname, flags, lineno=None):
  86.         self.expr = expr
  87.         self.attrname = attrname
  88.         self.flags = flags
  89.         self.lineno = lineno
  90.  
  91.     def getChildren(self):
  92.         return self.expr, self.attrname, self.flags
  93.  
  94.     def getChildNodes(self):
  95.         return self.expr,
  96.  
  97.     def __repr__(self):
  98.         return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))
  99.  
  100. class AssList(Node):
  101.     def __init__(self, nodes, lineno=None):
  102.         self.nodes = nodes
  103.         self.lineno = lineno
  104.  
  105.     def getChildren(self):
  106.         return tuple(flatten(self.nodes))
  107.  
  108.     def getChildNodes(self):
  109.         nodelist = []
  110.         nodelist.extend(flatten_nodes(self.nodes))
  111.         return tuple(nodelist)
  112.  
  113.     def __repr__(self):
  114.         return "AssList(%s)" % (repr(self.nodes),)
  115.  
  116. class AssName(Node):
  117.     def __init__(self, name, flags, lineno=None):
  118.         self.name = name
  119.         self.flags = flags
  120.         self.lineno = lineno
  121.  
  122.     def getChildren(self):
  123.         return self.name, self.flags
  124.  
  125.     def getChildNodes(self):
  126.         return ()
  127.  
  128.     def __repr__(self):
  129.         return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))
  130.  
  131. class AssTuple(Node):
  132.     def __init__(self, nodes, lineno=None):
  133.         self.nodes = nodes
  134.         self.lineno = lineno
  135.  
  136.     def getChildren(self):
  137.         return tuple(flatten(self.nodes))
  138.  
  139.     def getChildNodes(self):
  140.         nodelist = []
  141.         nodelist.extend(flatten_nodes(self.nodes))
  142.         return tuple(nodelist)
  143.  
  144.     def __repr__(self):
  145.         return "AssTuple(%s)" % (repr(self.nodes),)
  146.  
  147. class Assert(Node):
  148.     def __init__(self, test, fail, lineno=None):
  149.         self.test = test
  150.         self.fail = fail
  151.         self.lineno = lineno
  152.  
  153.     def getChildren(self):
  154.         children = []
  155.         children.append(self.test)
  156.         children.append(self.fail)
  157.         return tuple(children)
  158.  
  159.     def getChildNodes(self):
  160.         nodelist = []
  161.         nodelist.append(self.test)
  162.         if self.fail is not None:
  163.             nodelist.append(self.fail)
  164.         return tuple(nodelist)
  165.  
  166.     def __repr__(self):
  167.         return "Assert(%s, %s)" % (repr(self.test), repr(self.fail))
  168.  
  169. class Assign(Node):
  170.     def __init__(self, nodes, expr, lineno=None):
  171.         self.nodes = nodes
  172.         self.expr = expr
  173.         self.lineno = lineno
  174.  
  175.     def getChildren(self):
  176.         children = []
  177.         children.extend(flatten(self.nodes))
  178.         children.append(self.expr)
  179.         return tuple(children)
  180.  
  181.     def getChildNodes(self):
  182.         nodelist = []
  183.         nodelist.extend(flatten_nodes(self.nodes))
  184.         nodelist.append(self.expr)
  185.         return tuple(nodelist)
  186.  
  187.     def __repr__(self):
  188.         return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))
  189.  
  190. class AugAssign(Node):
  191.     def __init__(self, node, op, expr, lineno=None):
  192.         self.node = node
  193.         self.op = op
  194.         self.expr = expr
  195.         self.lineno = lineno
  196.  
  197.     def getChildren(self):
  198.         return self.node, self.op, self.expr
  199.  
  200.     def getChildNodes(self):
  201.         return self.node, self.expr
  202.  
  203.     def __repr__(self):
  204.         return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))
  205.  
  206. class Backquote(Node):
  207.     def __init__(self, expr, lineno=None):
  208.         self.expr = expr
  209.         self.lineno = lineno
  210.  
  211.     def getChildren(self):
  212.         return self.expr,
  213.  
  214.     def getChildNodes(self):
  215.         return self.expr,
  216.  
  217.     def __repr__(self):
  218.         return "Backquote(%s)" % (repr(self.expr),)
  219.  
  220. class Bitand(Node):
  221.     def __init__(self, nodes, lineno=None):
  222.         self.nodes = nodes
  223.         self.lineno = lineno
  224.  
  225.     def getChildren(self):
  226.         return tuple(flatten(self.nodes))
  227.  
  228.     def getChildNodes(self):
  229.         nodelist = []
  230.         nodelist.extend(flatten_nodes(self.nodes))
  231.         return tuple(nodelist)
  232.  
  233.     def __repr__(self):
  234.         return "Bitand(%s)" % (repr(self.nodes),)
  235.  
  236. class Bitor(Node):
  237.     def __init__(self, nodes, lineno=None):
  238.         self.nodes = nodes
  239.         self.lineno = lineno
  240.  
  241.     def getChildren(self):
  242.         return tuple(flatten(self.nodes))
  243.  
  244.     def getChildNodes(self):
  245.         nodelist = []
  246.         nodelist.extend(flatten_nodes(self.nodes))
  247.         return tuple(nodelist)
  248.  
  249.     def __repr__(self):
  250.         return "Bitor(%s)" % (repr(self.nodes),)
  251.  
  252. class Bitxor(Node):
  253.     def __init__(self, nodes, lineno=None):
  254.         self.nodes = nodes
  255.         self.lineno = lineno
  256.  
  257.     def getChildren(self):
  258.         return tuple(flatten(self.nodes))
  259.  
  260.     def getChildNodes(self):
  261.         nodelist = []
  262.         nodelist.extend(flatten_nodes(self.nodes))
  263.         return tuple(nodelist)
  264.  
  265.     def __repr__(self):
  266.         return "Bitxor(%s)" % (repr(self.nodes),)
  267.  
  268. class Break(Node):
  269.     def __init__(self, lineno=None):
  270.         self.lineno = lineno
  271.  
  272.     def getChildren(self):
  273.         return ()
  274.  
  275.     def getChildNodes(self):
  276.         return ()
  277.  
  278.     def __repr__(self):
  279.         return "Break()"
  280.  
  281. class CallFunc(Node):
  282.     def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None):
  283.         self.node = node
  284.         self.args = args
  285.         self.star_args = star_args
  286.         self.dstar_args = dstar_args
  287.         self.lineno = lineno
  288.  
  289.     def getChildren(self):
  290.         children = []
  291.         children.append(self.node)
  292.         children.extend(flatten(self.args))
  293.         children.append(self.star_args)
  294.         children.append(self.dstar_args)
  295.         return tuple(children)
  296.  
  297.     def getChildNodes(self):
  298.         nodelist = []
  299.         nodelist.append(self.node)
  300.         nodelist.extend(flatten_nodes(self.args))
  301.         if self.star_args is not None:
  302.             nodelist.append(self.star_args)
  303.         if self.dstar_args is not None:
  304.             nodelist.append(self.dstar_args)
  305.         return tuple(nodelist)
  306.  
  307.     def __repr__(self):
  308.         return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
  309.  
  310. class Class(Node):
  311.     def __init__(self, name, bases, doc, code, lineno=None):
  312.         self.name = name
  313.         self.bases = bases
  314.         self.doc = doc
  315.         self.code = code
  316.         self.lineno = lineno
  317.  
  318.     def getChildren(self):
  319.         children = []
  320.         children.append(self.name)
  321.         children.extend(flatten(self.bases))
  322.         children.append(self.doc)
  323.         children.append(self.code)
  324.         return tuple(children)
  325.  
  326.     def getChildNodes(self):
  327.         nodelist = []
  328.         nodelist.extend(flatten_nodes(self.bases))
  329.         nodelist.append(self.code)
  330.         return tuple(nodelist)
  331.  
  332.     def __repr__(self):
  333.         return "Class(%s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code))
  334.  
  335. class Compare(Node):
  336.     def __init__(self, expr, ops, lineno=None):
  337.         self.expr = expr
  338.         self.ops = ops
  339.         self.lineno = lineno
  340.  
  341.     def getChildren(self):
  342.         children = []
  343.         children.append(self.expr)
  344.         children.extend(flatten(self.ops))
  345.         return tuple(children)
  346.  
  347.     def getChildNodes(self):
  348.         nodelist = []
  349.         nodelist.append(self.expr)
  350.         nodelist.extend(flatten_nodes(self.ops))
  351.         return tuple(nodelist)
  352.  
  353.     def __repr__(self):
  354.         return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))
  355.  
  356. class Const(Node):
  357.     def __init__(self, value, lineno=None):
  358.         self.value = value
  359.         self.lineno = lineno
  360.  
  361.     def getChildren(self):
  362.         return self.value,
  363.  
  364.     def getChildNodes(self):
  365.         return ()
  366.  
  367.     def __repr__(self):
  368.         return "Const(%s)" % (repr(self.value),)
  369.  
  370. class Continue(Node):
  371.     def __init__(self, lineno=None):
  372.         self.lineno = lineno
  373.  
  374.     def getChildren(self):
  375.         return ()
  376.  
  377.     def getChildNodes(self):
  378.         return ()
  379.  
  380.     def __repr__(self):
  381.         return "Continue()"
  382.  
  383. class Decorators(Node):
  384.     def __init__(self, nodes, lineno=None):
  385.         self.nodes = nodes
  386.         self.lineno = lineno
  387.  
  388.     def getChildren(self):
  389.         return tuple(flatten(self.nodes))
  390.  
  391.     def getChildNodes(self):
  392.         nodelist = []
  393.         nodelist.extend(flatten_nodes(self.nodes))
  394.         return tuple(nodelist)
  395.  
  396.     def __repr__(self):
  397.         return "Decorators(%s)" % (repr(self.nodes),)
  398.  
  399. class Dict(Node):
  400.     def __init__(self, items, lineno=None):
  401.         self.items = items
  402.         self.lineno = lineno
  403.  
  404.     def getChildren(self):
  405.         return tuple(flatten(self.items))
  406.  
  407.     def getChildNodes(self):
  408.         nodelist = []
  409.         nodelist.extend(flatten_nodes(self.items))
  410.         return tuple(nodelist)
  411.  
  412.     def __repr__(self):
  413.         return "Dict(%s)" % (repr(self.items),)
  414.  
  415. class Discard(Node):
  416.     def __init__(self, expr, lineno=None):
  417.         self.expr = expr
  418.         self.lineno = lineno
  419.  
  420.     def getChildren(self):
  421.         return self.expr,
  422.  
  423.     def getChildNodes(self):
  424.         return self.expr,
  425.  
  426.     def __repr__(self):
  427.         return "Discard(%s)" % (repr(self.expr),)
  428.  
  429. class Div(Node):
  430.     def __init__(self, (left, right), lineno=None):
  431.         self.left = left
  432.         self.right = right
  433.         self.lineno = lineno
  434.  
  435.     def getChildren(self):
  436.         return self.left, self.right
  437.  
  438.     def getChildNodes(self):
  439.         return self.left, self.right
  440.  
  441.     def __repr__(self):
  442.         return "Div((%s, %s))" % (repr(self.left), repr(self.right))
  443.  
  444. class Ellipsis(Node):
  445.     def __init__(self, lineno=None):
  446.         self.lineno = lineno
  447.  
  448.     def getChildren(self):
  449.         return ()
  450.  
  451.     def getChildNodes(self):
  452.         return ()
  453.  
  454.     def __repr__(self):
  455.         return "Ellipsis()"
  456.  
  457. class Exec(Node):
  458.     def __init__(self, expr, locals, globals, lineno=None):
  459.         self.expr = expr
  460.         self.locals = locals
  461.         self.globals = globals
  462.         self.lineno = lineno
  463.  
  464.     def getChildren(self):
  465.         children = []
  466.         children.append(self.expr)
  467.         children.append(self.locals)
  468.         children.append(self.globals)
  469.         return tuple(children)
  470.  
  471.     def getChildNodes(self):
  472.         nodelist = []
  473.         nodelist.append(self.expr)
  474.         if self.locals is not None:
  475.             nodelist.append(self.locals)
  476.         if self.globals is not None:
  477.             nodelist.append(self.globals)
  478.         return tuple(nodelist)
  479.  
  480.     def __repr__(self):
  481.         return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals))
  482.  
  483. class FloorDiv(Node):
  484.     def __init__(self, (left, right), lineno=None):
  485.         self.left = left
  486.         self.right = right
  487.         self.lineno = lineno
  488.  
  489.     def getChildren(self):
  490.         return self.left, self.right
  491.  
  492.     def getChildNodes(self):
  493.         return self.left, self.right
  494.  
  495.     def __repr__(self):
  496.         return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right))
  497.  
  498. class For(Node):
  499.     def __init__(self, assign, list, body, else_, lineno=None):
  500.         self.assign = assign
  501.         self.list = list
  502.         self.body = body
  503.         self.else_ = else_
  504.         self.lineno = lineno
  505.  
  506.     def getChildren(self):
  507.         children = []
  508.         children.append(self.assign)
  509.         children.append(self.list)
  510.         children.append(self.body)
  511.         children.append(self.else_)
  512.         return tuple(children)
  513.  
  514.     def getChildNodes(self):
  515.         nodelist = []
  516.         nodelist.append(self.assign)
  517.         nodelist.append(self.list)
  518.         nodelist.append(self.body)
  519.         if self.else_ is not None:
  520.             nodelist.append(self.else_)
  521.         return tuple(nodelist)
  522.  
  523.     def __repr__(self):
  524.         return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
  525.  
  526. class From(Node):
  527.     def __init__(self, modname, names, level, lineno=None):
  528.         self.modname = modname
  529.         self.names = names
  530.         self.level = level
  531.         self.lineno = lineno
  532.  
  533.     def getChildren(self):
  534.         return self.modname, self.names, self.level
  535.  
  536.     def getChildNodes(self):
  537.         return ()
  538.  
  539.     def __repr__(self):
  540.         return "From(%s, %s, %s)" % (repr(self.modname), repr(self.names), repr(self.level))
  541.  
  542. class Function(Node):
  543.     def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None):
  544.         self.decorators = decorators
  545.         self.name = name
  546.         self.argnames = argnames
  547.         self.defaults = defaults
  548.         self.flags = flags
  549.         self.doc = doc
  550.         self.code = code
  551.         self.lineno = lineno
  552.         self.varargs = self.kwargs = None
  553.         if flags & CO_VARARGS:
  554.             self.varargs = 1
  555.         if flags & CO_VARKEYWORDS:
  556.             self.kwargs = 1
  557.  
  558.  
  559.  
  560.     def getChildren(self):
  561.         children = []
  562.         children.append(self.decorators)
  563.         children.append(self.name)
  564.         children.append(self.argnames)
  565.         children.extend(flatten(self.defaults))
  566.         children.append(self.flags)
  567.         children.append(self.doc)
  568.         children.append(self.code)
  569.         return tuple(children)
  570.  
  571.     def getChildNodes(self):
  572.         nodelist = []
  573.         if self.decorators is not None:
  574.             nodelist.append(self.decorators)
  575.         nodelist.extend(flatten_nodes(self.defaults))
  576.         nodelist.append(self.code)
  577.         return tuple(nodelist)
  578.  
  579.     def __repr__(self):
  580.         return "Function(%s, %s, %s, %s, %s, %s, %s)" % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
  581.  
  582. class GenExpr(Node):
  583.     def __init__(self, code, lineno=None):
  584.         self.code = code
  585.         self.lineno = lineno
  586.         self.argnames = ['.0']
  587.         self.varargs = self.kwargs = None
  588.  
  589.     def getChildren(self):
  590.         return self.code,
  591.  
  592.     def getChildNodes(self):
  593.         return self.code,
  594.  
  595.     def __repr__(self):
  596.         return "GenExpr(%s)" % (repr(self.code),)
  597.  
  598. class GenExprFor(Node):
  599.     def __init__(self, assign, iter, ifs, lineno=None):
  600.         self.assign = assign
  601.         self.iter = iter
  602.         self.ifs = ifs
  603.         self.lineno = lineno
  604.         self.is_outmost = False
  605.  
  606.  
  607.     def getChildren(self):
  608.         children = []
  609.         children.append(self.assign)
  610.         children.append(self.iter)
  611.         children.extend(flatten(self.ifs))
  612.         return tuple(children)
  613.  
  614.     def getChildNodes(self):
  615.         nodelist = []
  616.         nodelist.append(self.assign)
  617.         nodelist.append(self.iter)
  618.         nodelist.extend(flatten_nodes(self.ifs))
  619.         return tuple(nodelist)
  620.  
  621.     def __repr__(self):
  622.         return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs))
  623.  
  624. class GenExprIf(Node):
  625.     def __init__(self, test, lineno=None):
  626.         self.test = test
  627.         self.lineno = lineno
  628.  
  629.     def getChildren(self):
  630.         return self.test,
  631.  
  632.     def getChildNodes(self):
  633.         return self.test,
  634.  
  635.     def __repr__(self):
  636.         return "GenExprIf(%s)" % (repr(self.test),)
  637.  
  638. class GenExprInner(Node):
  639.     def __init__(self, expr, quals, lineno=None):
  640.         self.expr = expr
  641.         self.quals = quals
  642.         self.lineno = lineno
  643.  
  644.     def getChildren(self):
  645.         children = []
  646.         children.append(self.expr)
  647.         children.extend(flatten(self.quals))
  648.         return tuple(children)
  649.  
  650.     def getChildNodes(self):
  651.         nodelist = []
  652.         nodelist.append(self.expr)
  653.         nodelist.extend(flatten_nodes(self.quals))
  654.         return tuple(nodelist)
  655.  
  656.     def __repr__(self):
  657.         return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals))
  658.  
  659. class Getattr(Node):
  660.     def __init__(self, expr, attrname, lineno=None):
  661.         self.expr = expr
  662.         self.attrname = attrname
  663.         self.lineno = lineno
  664.  
  665.     def getChildren(self):
  666.         return self.expr, self.attrname
  667.  
  668.     def getChildNodes(self):
  669.         return self.expr,
  670.  
  671.     def __repr__(self):
  672.         return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname))
  673.  
  674. class Global(Node):
  675.     def __init__(self, names, lineno=None):
  676.         self.names = names
  677.         self.lineno = lineno
  678.  
  679.     def getChildren(self):
  680.         return self.names,
  681.  
  682.     def getChildNodes(self):
  683.         return ()
  684.  
  685.     def __repr__(self):
  686.         return "Global(%s)" % (repr(self.names),)
  687.  
  688. class If(Node):
  689.     def __init__(self, tests, else_, lineno=None):
  690.         self.tests = tests
  691.         self.else_ = else_
  692.         self.lineno = lineno
  693.  
  694.     def getChildren(self):
  695.         children = []
  696.         children.extend(flatten(self.tests))
  697.         children.append(self.else_)
  698.         return tuple(children)
  699.  
  700.     def getChildNodes(self):
  701.         nodelist = []
  702.         nodelist.extend(flatten_nodes(self.tests))
  703.         if self.else_ is not None:
  704.             nodelist.append(self.else_)
  705.         return tuple(nodelist)
  706.  
  707.     def __repr__(self):
  708.         return "If(%s, %s)" % (repr(self.tests), repr(self.else_))
  709.  
  710. class IfExp(Node):
  711.     def __init__(self, test, then, else_, lineno=None):
  712.         self.test = test
  713.         self.then = then
  714.         self.else_ = else_
  715.         self.lineno = lineno
  716.  
  717.     def getChildren(self):
  718.         return self.test, self.then, self.else_
  719.  
  720.     def getChildNodes(self):
  721.         return self.test, self.then, self.else_
  722.  
  723.     def __repr__(self):
  724.         return "IfExp(%s, %s, %s)" % (repr(self.test), repr(self.then), repr(self.else_))
  725.  
  726. class Import(Node):
  727.     def __init__(self, names, lineno=None):
  728.         self.names = names
  729.         self.lineno = lineno
  730.  
  731.     def getChildren(self):
  732.         return self.names,
  733.  
  734.     def getChildNodes(self):
  735.         return ()
  736.  
  737.     def __repr__(self):
  738.         return "Import(%s)" % (repr(self.names),)
  739.  
  740. class Invert(Node):
  741.     def __init__(self, expr, lineno=None):
  742.         self.expr = expr
  743.         self.lineno = lineno
  744.  
  745.     def getChildren(self):
  746.         return self.expr,
  747.  
  748.     def getChildNodes(self):
  749.         return self.expr,
  750.  
  751.     def __repr__(self):
  752.         return "Invert(%s)" % (repr(self.expr),)
  753.  
  754. class Keyword(Node):
  755.     def __init__(self, name, expr, lineno=None):
  756.         self.name = name
  757.         self.expr = expr
  758.         self.lineno = lineno
  759.  
  760.     def getChildren(self):
  761.         return self.name, self.expr
  762.  
  763.     def getChildNodes(self):
  764.         return self.expr,
  765.  
  766.     def __repr__(self):
  767.         return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))
  768.  
  769. class Lambda(Node):
  770.     def __init__(self, argnames, defaults, flags, code, lineno=None):
  771.         self.argnames = argnames
  772.         self.defaults = defaults
  773.         self.flags = flags
  774.         self.code = code
  775.         self.lineno = lineno
  776.         self.varargs = self.kwargs = None
  777.         if flags & CO_VARARGS:
  778.             self.varargs = 1
  779.         if flags & CO_VARKEYWORDS:
  780.             self.kwargs = 1
  781.  
  782.  
  783.  
  784.     def getChildren(self):
  785.         children = []
  786.         children.append(self.argnames)
  787.         children.extend(flatten(self.defaults))
  788.         children.append(self.flags)
  789.         children.append(self.code)
  790.         return tuple(children)
  791.  
  792.     def getChildNodes(self):
  793.         nodelist = []
  794.         nodelist.extend(flatten_nodes(self.defaults))
  795.         nodelist.append(self.code)
  796.         return tuple(nodelist)
  797.  
  798.     def __repr__(self):
  799.         return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
  800.  
  801. class LeftShift(Node):
  802.     def __init__(self, (left, right), lineno=None):
  803.         self.left = left
  804.         self.right = right
  805.         self.lineno = lineno
  806.  
  807.     def getChildren(self):
  808.         return self.left, self.right
  809.  
  810.     def getChildNodes(self):
  811.         return self.left, self.right
  812.  
  813.     def __repr__(self):
  814.         return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right))
  815.  
  816. class List(Node):
  817.     def __init__(self, nodes, lineno=None):
  818.         self.nodes = nodes
  819.         self.lineno = lineno
  820.  
  821.     def getChildren(self):
  822.         return tuple(flatten(self.nodes))
  823.  
  824.     def getChildNodes(self):
  825.         nodelist = []
  826.         nodelist.extend(flatten_nodes(self.nodes))
  827.         return tuple(nodelist)
  828.  
  829.     def __repr__(self):
  830.         return "List(%s)" % (repr(self.nodes),)
  831.  
  832. class ListComp(Node):
  833.     def __init__(self, expr, quals, lineno=None):
  834.         self.expr = expr
  835.         self.quals = quals
  836.         self.lineno = lineno
  837.  
  838.     def getChildren(self):
  839.         children = []
  840.         children.append(self.expr)
  841.         children.extend(flatten(self.quals))
  842.         return tuple(children)
  843.  
  844.     def getChildNodes(self):
  845.         nodelist = []
  846.         nodelist.append(self.expr)
  847.         nodelist.extend(flatten_nodes(self.quals))
  848.         return tuple(nodelist)
  849.  
  850.     def __repr__(self):
  851.         return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))
  852.  
  853. class ListCompFor(Node):
  854.     def __init__(self, assign, list, ifs, lineno=None):
  855.         self.assign = assign
  856.         self.list = list
  857.         self.ifs = ifs
  858.         self.lineno = lineno
  859.  
  860.     def getChildren(self):
  861.         children = []
  862.         children.append(self.assign)
  863.         children.append(self.list)
  864.         children.extend(flatten(self.ifs))
  865.         return tuple(children)
  866.  
  867.     def getChildNodes(self):
  868.         nodelist = []
  869.         nodelist.append(self.assign)
  870.         nodelist.append(self.list)
  871.         nodelist.extend(flatten_nodes(self.ifs))
  872.         return tuple(nodelist)
  873.  
  874.     def __repr__(self):
  875.         return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))
  876.  
  877. class ListCompIf(Node):
  878.     def __init__(self, test, lineno=None):
  879.         self.test = test
  880.         self.lineno = lineno
  881.  
  882.     def getChildren(self):
  883.         return self.test,
  884.  
  885.     def getChildNodes(self):
  886.         return self.test,
  887.  
  888.     def __repr__(self):
  889.         return "ListCompIf(%s)" % (repr(self.test),)
  890.  
  891. class Mod(Node):
  892.     def __init__(self, (left, right), lineno=None):
  893.         self.left = left
  894.         self.right = right
  895.         self.lineno = lineno
  896.  
  897.     def getChildren(self):
  898.         return self.left, self.right
  899.  
  900.     def getChildNodes(self):
  901.         return self.left, self.right
  902.  
  903.     def __repr__(self):
  904.         return "Mod((%s, %s))" % (repr(self.left), repr(self.right))
  905.  
  906. class Module(Node):
  907.     def __init__(self, doc, node, lineno=None):
  908.         self.doc = doc
  909.         self.node = node
  910.         self.lineno = lineno
  911.  
  912.     def getChildren(self):
  913.         return self.doc, self.node
  914.  
  915.     def getChildNodes(self):
  916.         return self.node,
  917.  
  918.     def __repr__(self):
  919.         return "Module(%s, %s)" % (repr(self.doc), repr(self.node))
  920.  
  921. class Mul(Node):
  922.     def __init__(self, (left, right), lineno=None):
  923.         self.left = left
  924.         self.right = right
  925.         self.lineno = lineno
  926.  
  927.     def getChildren(self):
  928.         return self.left, self.right
  929.  
  930.     def getChildNodes(self):
  931.         return self.left, self.right
  932.  
  933.     def __repr__(self):
  934.         return "Mul((%s, %s))" % (repr(self.left), repr(self.right))
  935.  
  936. class Name(Node):
  937.     def __init__(self, name, lineno=None):
  938.         self.name = name
  939.         self.lineno = lineno
  940.  
  941.     def getChildren(self):
  942.         return self.name,
  943.  
  944.     def getChildNodes(self):
  945.         return ()
  946.  
  947.     def __repr__(self):
  948.         return "Name(%s)" % (repr(self.name),)
  949.  
  950. class Not(Node):
  951.     def __init__(self, expr, lineno=None):
  952.         self.expr = expr
  953.         self.lineno = lineno
  954.  
  955.     def getChildren(self):
  956.         return self.expr,
  957.  
  958.     def getChildNodes(self):
  959.         return self.expr,
  960.  
  961.     def __repr__(self):
  962.         return "Not(%s)" % (repr(self.expr),)
  963.  
  964. class Or(Node):
  965.     def __init__(self, nodes, lineno=None):
  966.         self.nodes = nodes
  967.         self.lineno = lineno
  968.  
  969.     def getChildren(self):
  970.         return tuple(flatten(self.nodes))
  971.  
  972.     def getChildNodes(self):
  973.         nodelist = []
  974.         nodelist.extend(flatten_nodes(self.nodes))
  975.         return tuple(nodelist)
  976.  
  977.     def __repr__(self):
  978.         return "Or(%s)" % (repr(self.nodes),)
  979.  
  980. class Pass(Node):
  981.     def __init__(self, lineno=None):
  982.         self.lineno = lineno
  983.  
  984.     def getChildren(self):
  985.         return ()
  986.  
  987.     def getChildNodes(self):
  988.         return ()
  989.  
  990.     def __repr__(self):
  991.         return "Pass()"
  992.  
  993. class Power(Node):
  994.     def __init__(self, (left, right), lineno=None):
  995.         self.left = left
  996.         self.right = right
  997.         self.lineno = lineno
  998.  
  999.     def getChildren(self):
  1000.         return self.left, self.right
  1001.  
  1002.     def getChildNodes(self):
  1003.         return self.left, self.right
  1004.  
  1005.     def __repr__(self):
  1006.         return "Power((%s, %s))" % (repr(self.left), repr(self.right))
  1007.  
  1008. class Print(Node):
  1009.     def __init__(self, nodes, dest, lineno=None):
  1010.         self.nodes = nodes
  1011.         self.dest = dest
  1012.         self.lineno = lineno
  1013.  
  1014.     def getChildren(self):
  1015.         children = []
  1016.         children.extend(flatten(self.nodes))
  1017.         children.append(self.dest)
  1018.         return tuple(children)
  1019.  
  1020.     def getChildNodes(self):
  1021.         nodelist = []
  1022.         nodelist.extend(flatten_nodes(self.nodes))
  1023.         if self.dest is not None:
  1024.             nodelist.append(self.dest)
  1025.         return tuple(nodelist)
  1026.  
  1027.     def __repr__(self):
  1028.         return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest))
  1029.  
  1030. class Printnl(Node):
  1031.     def __init__(self, nodes, dest, lineno=None):
  1032.         self.nodes = nodes
  1033.         self.dest = dest
  1034.         self.lineno = lineno
  1035.  
  1036.     def getChildren(self):
  1037.         children = []
  1038.         children.extend(flatten(self.nodes))
  1039.         children.append(self.dest)
  1040.         return tuple(children)
  1041.  
  1042.     def getChildNodes(self):
  1043.         nodelist = []
  1044.         nodelist.extend(flatten_nodes(self.nodes))
  1045.         if self.dest is not None:
  1046.             nodelist.append(self.dest)
  1047.         return tuple(nodelist)
  1048.  
  1049.     def __repr__(self):
  1050.         return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))
  1051.  
  1052. class Raise(Node):
  1053.     def __init__(self, expr1, expr2, expr3, lineno=None):
  1054.         self.expr1 = expr1
  1055.         self.expr2 = expr2
  1056.         self.expr3 = expr3
  1057.         self.lineno = lineno
  1058.  
  1059.     def getChildren(self):
  1060.         children = []
  1061.         children.append(self.expr1)
  1062.         children.append(self.expr2)
  1063.         children.append(self.expr3)
  1064.         return tuple(children)
  1065.  
  1066.     def getChildNodes(self):
  1067.         nodelist = []
  1068.         if self.expr1 is not None:
  1069.             nodelist.append(self.expr1)
  1070.         if self.expr2 is not None:
  1071.             nodelist.append(self.expr2)
  1072.         if self.expr3 is not None:
  1073.             nodelist.append(self.expr3)
  1074.         return tuple(nodelist)
  1075.  
  1076.     def __repr__(self):
  1077.         return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
  1078.  
  1079. class Return(Node):
  1080.     def __init__(self, value, lineno=None):
  1081.         self.value = value
  1082.         self.lineno = lineno
  1083.  
  1084.     def getChildren(self):
  1085.         return self.value,
  1086.  
  1087.     def getChildNodes(self):
  1088.         return self.value,
  1089.  
  1090.     def __repr__(self):
  1091.         return "Return(%s)" % (repr(self.value),)
  1092.  
  1093. class RightShift(Node):
  1094.     def __init__(self, (left, right), lineno=None):
  1095.         self.left = left
  1096.         self.right = right
  1097.         self.lineno = lineno
  1098.  
  1099.     def getChildren(self):
  1100.         return self.left, self.right
  1101.  
  1102.     def getChildNodes(self):
  1103.         return self.left, self.right
  1104.  
  1105.     def __repr__(self):
  1106.         return "RightShift((%s, %s))" % (repr(self.left), repr(self.right))
  1107.  
  1108. class Slice(Node):
  1109.     def __init__(self, expr, flags, lower, upper, lineno=None):
  1110.         self.expr = expr
  1111.         self.flags = flags
  1112.         self.lower = lower
  1113.         self.upper = upper
  1114.         self.lineno = lineno
  1115.  
  1116.     def getChildren(self):
  1117.         children = []
  1118.         children.append(self.expr)
  1119.         children.append(self.flags)
  1120.         children.append(self.lower)
  1121.         children.append(self.upper)
  1122.         return tuple(children)
  1123.  
  1124.     def getChildNodes(self):
  1125.         nodelist = []
  1126.         nodelist.append(self.expr)
  1127.         if self.lower is not None:
  1128.             nodelist.append(self.lower)
  1129.         if self.upper is not None:
  1130.             nodelist.append(self.upper)
  1131.         return tuple(nodelist)
  1132.  
  1133.     def __repr__(self):
  1134.         return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
  1135.  
  1136. class Sliceobj(Node):
  1137.     def __init__(self, nodes, lineno=None):
  1138.         self.nodes = nodes
  1139.         self.lineno = lineno
  1140.  
  1141.     def getChildren(self):
  1142.         return tuple(flatten(self.nodes))
  1143.  
  1144.     def getChildNodes(self):
  1145.         nodelist = []
  1146.         nodelist.extend(flatten_nodes(self.nodes))
  1147.         return tuple(nodelist)
  1148.  
  1149.     def __repr__(self):
  1150.         return "Sliceobj(%s)" % (repr(self.nodes),)
  1151.  
  1152. class Stmt(Node):
  1153.     def __init__(self, nodes, lineno=None):
  1154.         self.nodes = nodes
  1155.         self.lineno = lineno
  1156.  
  1157.     def getChildren(self):
  1158.         return tuple(flatten(self.nodes))
  1159.  
  1160.     def getChildNodes(self):
  1161.         nodelist = []
  1162.         nodelist.extend(flatten_nodes(self.nodes))
  1163.         return tuple(nodelist)
  1164.  
  1165.     def __repr__(self):
  1166.         return "Stmt(%s)" % (repr(self.nodes),)
  1167.  
  1168. class Sub(Node):
  1169.     def __init__(self, (left, right), lineno=None):
  1170.         self.left = left
  1171.         self.right = right
  1172.         self.lineno = lineno
  1173.  
  1174.     def getChildren(self):
  1175.         return self.left, self.right
  1176.  
  1177.     def getChildNodes(self):
  1178.         return self.left, self.right
  1179.  
  1180.     def __repr__(self):
  1181.         return "Sub((%s, %s))" % (repr(self.left), repr(self.right))
  1182.  
  1183. class Subscript(Node):
  1184.     def __init__(self, expr, flags, subs, lineno=None):
  1185.         self.expr = expr
  1186.         self.flags = flags
  1187.         self.subs = subs
  1188.         self.lineno = lineno
  1189.  
  1190.     def getChildren(self):
  1191.         children = []
  1192.         children.append(self.expr)
  1193.         children.append(self.flags)
  1194.         children.extend(flatten(self.subs))
  1195.         return tuple(children)
  1196.  
  1197.     def getChildNodes(self):
  1198.         nodelist = []
  1199.         nodelist.append(self.expr)
  1200.         nodelist.extend(flatten_nodes(self.subs))
  1201.         return tuple(nodelist)
  1202.  
  1203.     def __repr__(self):
  1204.         return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs))
  1205.  
  1206. class TryExcept(Node):
  1207.     def __init__(self, body, handlers, else_, lineno=None):
  1208.         self.body = body
  1209.         self.handlers = handlers
  1210.         self.else_ = else_
  1211.         self.lineno = lineno
  1212.  
  1213.     def getChildren(self):
  1214.         children = []
  1215.         children.append(self.body)
  1216.         children.extend(flatten(self.handlers))
  1217.         children.append(self.else_)
  1218.         return tuple(children)
  1219.  
  1220.     def getChildNodes(self):
  1221.         nodelist = []
  1222.         nodelist.append(self.body)
  1223.         nodelist.extend(flatten_nodes(self.handlers))
  1224.         if self.else_ is not None:
  1225.             nodelist.append(self.else_)
  1226.         return tuple(nodelist)
  1227.  
  1228.     def __repr__(self):
  1229.         return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_))
  1230.  
  1231. class TryFinally(Node):
  1232.     def __init__(self, body, final, lineno=None):
  1233.         self.body = body
  1234.         self.final = final
  1235.         self.lineno = lineno
  1236.  
  1237.     def getChildren(self):
  1238.         return self.body, self.final
  1239.  
  1240.     def getChildNodes(self):
  1241.         return self.body, self.final
  1242.  
  1243.     def __repr__(self):
  1244.         return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final))
  1245.  
  1246. class Tuple(Node):
  1247.     def __init__(self, nodes, lineno=None):
  1248.         self.nodes = nodes
  1249.         self.lineno = lineno
  1250.  
  1251.     def getChildren(self):
  1252.         return tuple(flatten(self.nodes))
  1253.  
  1254.     def getChildNodes(self):
  1255.         nodelist = []
  1256.         nodelist.extend(flatten_nodes(self.nodes))
  1257.         return tuple(nodelist)
  1258.  
  1259.     def __repr__(self):
  1260.         return "Tuple(%s)" % (repr(self.nodes),)
  1261.  
  1262. class UnaryAdd(Node):
  1263.     def __init__(self, expr, lineno=None):
  1264.         self.expr = expr
  1265.         self.lineno = lineno
  1266.  
  1267.     def getChildren(self):
  1268.         return self.expr,
  1269.  
  1270.     def getChildNodes(self):
  1271.         return self.expr,
  1272.  
  1273.     def __repr__(self):
  1274.         return "UnaryAdd(%s)" % (repr(self.expr),)
  1275.  
  1276. class UnarySub(Node):
  1277.     def __init__(self, expr, lineno=None):
  1278.         self.expr = expr
  1279.         self.lineno = lineno
  1280.  
  1281.     def getChildren(self):
  1282.         return self.expr,
  1283.  
  1284.     def getChildNodes(self):
  1285.         return self.expr,
  1286.  
  1287.     def __repr__(self):
  1288.         return "UnarySub(%s)" % (repr(self.expr),)
  1289.  
  1290. class While(Node):
  1291.     def __init__(self, test, body, else_, lineno=None):
  1292.         self.test = test
  1293.         self.body = body
  1294.         self.else_ = else_
  1295.         self.lineno = lineno
  1296.  
  1297.     def getChildren(self):
  1298.         children = []
  1299.         children.append(self.test)
  1300.         children.append(self.body)
  1301.         children.append(self.else_)
  1302.         return tuple(children)
  1303.  
  1304.     def getChildNodes(self):
  1305.         nodelist = []
  1306.         nodelist.append(self.test)
  1307.         nodelist.append(self.body)
  1308.         if self.else_ is not None:
  1309.             nodelist.append(self.else_)
  1310.         return tuple(nodelist)
  1311.  
  1312.     def __repr__(self):
  1313.         return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_))
  1314.  
  1315. class With(Node):
  1316.     def __init__(self, expr, vars, body, lineno=None):
  1317.         self.expr = expr
  1318.         self.vars = vars
  1319.         self.body = body
  1320.         self.lineno = lineno
  1321.  
  1322.     def getChildren(self):
  1323.         children = []
  1324.         children.append(self.expr)
  1325.         children.append(self.vars)
  1326.         children.append(self.body)
  1327.         return tuple(children)
  1328.  
  1329.     def getChildNodes(self):
  1330.         nodelist = []
  1331.         nodelist.append(self.expr)
  1332.         if self.vars is not None:
  1333.             nodelist.append(self.vars)
  1334.         nodelist.append(self.body)
  1335.         return tuple(nodelist)
  1336.  
  1337.     def __repr__(self):
  1338.         return "With(%s, %s, %s)" % (repr(self.expr), repr(self.vars), repr(self.body))
  1339.  
  1340. class Yield(Node):
  1341.     def __init__(self, value, lineno=None):
  1342.         self.value = value
  1343.         self.lineno = lineno
  1344.  
  1345.     def getChildren(self):
  1346.         return self.value,
  1347.  
  1348.     def getChildNodes(self):
  1349.         return self.value,
  1350.  
  1351.     def __repr__(self):
  1352.         return "Yield(%s)" % (repr(self.value),)
  1353.  
  1354. for name, obj in globals().items():
  1355.     if isinstance(obj, type) and issubclass(obj, Node):
  1356.         nodes[name.lower()] = obj
  1357.